home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 26 / Cream of the Crop 26.iso / os2 / plnk081.zip / pilot-link.0.8.1 / Perl5 / Pilot.pm < prev    next >
Text File  |  1997-08-08  |  25KB  |  984 lines
  1. package PDA::Pilot;
  2.  
  3. require Exporter;
  4. require DynaLoader;
  5. require AutoLoader;
  6.  
  7. @ISA = qw(Exporter DynaLoader);
  8. # Items to export into callers namespace by default. Note: do not export
  9. # names by default without a very good reason. Use EXPORT_OK instead.
  10. # Do not simply export all your public functions/methods/constants.
  11. @EXPORT = qw(
  12.     PI_AF_SLP
  13.     PI_PF_LOOP
  14.     PI_PF_PADP
  15.     PI_PF_SLP
  16.     PI_PilotSocketConsole
  17.     PI_PilotSocketDLP
  18.     PI_PilotSocketDebugger
  19.     PI_PilotSocketRemoteUI
  20.     PI_SOCK_DGRAM
  21.     PI_SOCK_RAW
  22.     PI_SOCK_SEQPACKET
  23.     PI_SOCK_STREAM
  24.     dlpOpenRead
  25.     dlpOpenWrite
  26.     dlpOpenExclusive
  27.     dlpOpenSecret
  28.     dlpOpenReadWrite
  29.     dlpEndCodeNormal
  30.     dlpEndCodeOutOfMemory
  31.     dlpEndCodeUserCan
  32.     dlpEndCodeOther
  33.      dlpRecAttrDeleted
  34.     dlpRecAttrDirty
  35.     dlpRecAttrBusy
  36.     dlpRecAttrSecret
  37.     dlpRecAttrArchived
  38.      dlpDBFlagResource
  39.     dlpDBFlagReadOnly
  40.     dlpDBFlagAppInfoDirty
  41.     dlpDBFlagBackup
  42.     dlpDBFlagOpen
  43.     dlpDBFlagNewer
  44.     dlpDBFlagReset
  45.     dlpDBListRAM
  46.     dlpDBListROM
  47. );
  48. # Other items we are prepared to export if requested
  49. @EXPORT_OK = qw(
  50.     CompareTm
  51. );
  52.  
  53. sub AUTOLOAD {
  54.     # This AUTOLOAD is used to 'autoload' constants from the constant()
  55.     # XS function.  If a constant is not found then control is passed
  56.     # to the AUTOLOAD in AutoLoader.
  57.  
  58.     # NOTE: THIS AUTOLOAD FUNCTION IS FLAWED (but is the best we can do for now).
  59.     # Avoid old-style ``&CONST'' usage. Either remove the ``&'' or add ``()''.
  60.     if (@_ > 0) {
  61.     $AutoLoader::AUTOLOAD = $AUTOLOAD;
  62.     goto &AutoLoader::AUTOLOAD;
  63.     }
  64.     local($constname);
  65.     ($constname = $AUTOLOAD) =~ s/.*:://;
  66.     $val = constant($constname, @_ ? $_[0] : 0);
  67.     if ($! != 0) {
  68.     if ($! =~ /Invalid/) {
  69.         $AutoLoader::AUTOLOAD = $AUTOLOAD;
  70.         goto &AutoLoader::AUTOLOAD;
  71.     }
  72.     else {
  73.         ($pack,$file,$line) = caller;
  74.         die "Your vendor has not defined PDA::Pilot macro $constname, used at $file line $line.
  75. ";
  76.     }
  77.     }
  78.     eval "sub $AUTOLOAD { $val }";
  79.     goto &$AUTOLOAD;
  80. }
  81.  
  82. bootstrap PDA::Pilot;
  83. package PDA::Pilot::Block;
  84.  
  85. # Generic functions for "blocks", i.e., chunks of data from a Pilot.
  86.  
  87. sub new {
  88.     my($self,$data) = @_;
  89.     $self = bless {}, (ref($self) || $self);
  90.     if (defined($data)) {
  91.         $self->Unpack($data);
  92.     } else {
  93.         $self->Fill();
  94.     }
  95.     return $self;
  96. }
  97.  
  98. sub Unpack {
  99.  
  100. # Translate a "packed" block of binary data into a decent Perl representation
  101.  
  102.     my($self,$data) = @_;
  103.     $self->{raw} = $data;
  104. }
  105.  
  106. sub Pack {
  107.  
  108. # Translate a Perl representation of a data block into a string of binary data
  109.  
  110.     my($self) = @_;
  111.     return $self->{raw};
  112. }
  113.  
  114. sub Raw {
  115.  
  116. # Just copy the "raw" item straight through
  117.  
  118.     my($self) = @_;
  119.     return $self->{raw};
  120. }
  121.  
  122. sub Fill {
  123.  
  124. # Fill in a block with default Perl data
  125.  
  126. }
  127.  
  128. # Copy a block
  129.  
  130. sub Clone {
  131.     my($self) = @_;
  132.     my($k,$v);
  133.     my($new) = bless {}, ref($_);
  134.     for (($k,$v) = each %$self) { $new->{$k} = $v }
  135.     $new;
  136. }
  137.  
  138. package PDA::Pilot::Record;
  139.  
  140. # A class to represent generic database records
  141.  
  142. @ISA = qw(PDA::Pilot::Block);
  143.  
  144. sub new {
  145.     my($self,$data,$id,$attr,$cat,$index) = @_;
  146.     $self = bless { 
  147.         index => $index,
  148.         id => $id,
  149.         deleted => !!($attr & 0x80),
  150.         modified => !!($attr & 0x40),
  151.         busy => !!($attr & 0x20),
  152.         secret => !!($attr & 0x10),
  153.         archived => !!($attr & 0x08),
  154.         category => $cat}, 
  155.         (ref($self) || $self);
  156.     if (defined($data)) {
  157.         $self->Unpack($data);
  158.     } else {
  159.         $self->Fill();
  160.     }
  161.     return $self;
  162. }
  163.  
  164. package PDA::Pilot::Resource;
  165.  
  166. # A class to represent generic database resources
  167.  
  168. @ISA = qw(PDA::Pilot::Block);
  169.  
  170. sub new {
  171.     my($self,$data,$index,$type,$id) = @_;
  172.     $self = bless { index => $index, type => $type, id => $id}, 
  173.         (ref($self) || $self);
  174.     if (defined($data)) {
  175.         $self->Unpack($data);
  176.     } else {
  177.         $self->Fill();
  178.     }
  179.     return $self;
  180. }
  181.  
  182. package PDA::Pilot::AppBlock;
  183.  
  184. # A class to represent generic application-information blocks
  185.  
  186. @ISA = qw(PDA::Pilot::Block);
  187.  
  188. package PDA::Pilot::SortBlock;
  189.  
  190. # A class to represent generic sort-information blocks
  191.  
  192. @ISA = qw(PDA::Pilot::Block);
  193.  
  194. package PDA::Pilot::Pref;
  195.  
  196. # A class to represent generic preference blocks
  197.  
  198. @ISA = qw(PDA::Pilot::Block);
  199.  
  200. sub new {
  201.     my($self,$data,$creator,$id,$version,$backup) = @_;
  202.     $self = bless { creator => $creator, id => $id, version => $version, backup => $backup}, 
  203.         (ref($self) || $self);
  204.     if (defined($data)) {
  205.         $self->Unpack($data);
  206.     } else {
  207.         $self->Fill();
  208.     }
  209.     return $self;
  210. }
  211.  
  212. package PDA::Pilot::MemoRecord;
  213.  
  214. # A class to represent records of the Memo application
  215.  
  216. @ISA = qw(PDA::Pilot::Record);
  217.  
  218. sub Pack {
  219.     my($self) = @_;
  220.     return $self->{raw} = PDA::Pilot::Memo::Pack($self);
  221. }
  222.  
  223. sub Unpack {
  224.     my($self, $data) = @_;
  225.     $self->{raw} = $data;
  226.     PDA::Pilot::Memo::Unpack($self);
  227. }
  228.  
  229. package PDA::Pilot::MemoAppBlock;
  230.  
  231. # A class to represent records of the Memo application
  232.  
  233. @ISA = qw(PDA::Pilot::AppBlock);
  234.  
  235. sub Pack {
  236.     my($self) = @_;
  237.     return PDA::Pilot::Memo::PackAppBlock($self);
  238. }
  239.  
  240. sub Unpack {
  241.     my($self, $data) = @_;
  242.     $self->{raw} = $data;
  243.     PDA::Pilot::Memo::UnpackAppBlock($self);
  244. }
  245.  
  246. package PDA::Pilot::ToDoRecord;
  247.  
  248. # A class to represent records of the ToDo application
  249.  
  250. @ISA = qw(PDA::Pilot::Record);
  251.  
  252. sub Pack {
  253.     my($self) = @_;
  254.     return $self->{raw} = PDA::Pilot::ToDo::Pack($self);
  255. }
  256.  
  257. sub Unpack {
  258.     my($self, $data) = @_;
  259.     $self->{raw} = $data;
  260.     PDA::Pilot::ToDo::Unpack($self);
  261. }
  262.  
  263. package PDA::Pilot::ToDoAppBlock;
  264.  
  265. # A class to represent the app block of the ToDo application
  266.  
  267. @ISA = qw(PDA::Pilot::AppBlock);
  268.  
  269. sub Pack {
  270.     my($self) = @_;
  271.     return PDA::Pilot::ToDo::PackAppBlock($self);
  272. }
  273.  
  274. sub Unpack {
  275.     my($self, $data) = @_;
  276.     $self->{raw} = $data;
  277.     PDA::Pilot::ToDo::UnpackAppBlock($self);
  278. }
  279.  
  280. package PDA::Pilot::AddressRecord;
  281.  
  282. # A class to represent records of the Address application
  283.  
  284. @ISA = qw(PDA::Pilot::Record);
  285.  
  286. sub Pack {
  287.     my($self) = @_;
  288.     return $self->{raw} = PDA::Pilot::Address::Pack($self);
  289. }
  290.  
  291. sub Unpack {
  292.     my($self, $data) = @_;
  293.     $self->{raw} = $data;
  294.     PDA::Pilot::Address::Unpack($self);
  295. }
  296.  
  297. package PDA::Pilot::AddressAppBlock;
  298.  
  299. # A class to represent the app block of the Address application
  300.  
  301. @ISA = qw(PDA::Pilot::AppBlock);
  302.  
  303. sub Pack {
  304.     my($self) = @_;
  305.     return PDA::Pilot::Address::PackAppBlock($self);
  306. }
  307.  
  308. sub Unpack {
  309.     my($self, $data) = @_;
  310.     $self->{raw} = $data;
  311.     PDA::Pilot::Address::UnpackAppBlock($self);
  312. }
  313.  
  314. package PDA::Pilot::AppointmentRecord;
  315.  
  316. # A class to represent records of the Appointment application
  317.  
  318. @ISA = qw(PDA::Pilot::Record);
  319.  
  320. sub Pack {
  321.     my($self) = @_;
  322.     return PDA::Pilot::Appointment::Pack($self);
  323. }
  324.  
  325. sub Unpack {
  326.     my($self, $data) = @_;
  327.     $self->{raw} = $data;
  328.     PDA::Pilot::Appointment::Unpack($self);
  329. }
  330.  
  331. package PDA::Pilot::AppointmentAppBlock;
  332.  
  333. # A class to represent the app block of the Appointment application
  334.  
  335. @ISA = qw(PDA::Pilot::AppBlock);
  336.  
  337. sub Pack {
  338.     my($self) = @_;
  339.     return PDA::Pilot::Appointment::PackAppBlock($self);
  340. }
  341.  
  342. sub Unpack {
  343.     my($self, $data) = @_;
  344.     $self->{raw} = $data;
  345.     PDA::Pilot::Appointment::UnpackAppBlock($self);
  346. }
  347.  
  348. package PDA::Pilot::MailRecord;
  349.  
  350. # A class to represent records of the Mail application
  351.  
  352. @ISA = qw(PDA::Pilot::Record);
  353.  
  354. sub Pack {
  355.     my($self) = @_;
  356.     return PDA::Pilot::Mail::Pack($self);
  357. }
  358.  
  359. sub Unpack {
  360.     my($self, $data) = @_;
  361.     $self->{raw} = $data;
  362.     PDA::Pilot::Mail::Unpack($self);
  363. }
  364.  
  365. package PDA::Pilot::MailAppBlock;
  366.  
  367. # A class to represent the app block of the Mail application
  368.  
  369. @ISA = qw(PDA::Pilot::AppBlock);
  370.  
  371. sub Pack {
  372.     my($self) = @_;
  373.     return PDA::Pilot::Mail::PackAppBlock($self);
  374. }
  375.  
  376. sub Unpack {
  377.     my($self, $data) = @_;
  378.     $self->{raw} = $data;
  379.     PDA::Pilot::Mail::UnpackAppBlock($self);
  380. }
  381.  
  382. package PDA::Pilot::MailSyncPref;
  383.  
  384. # A class to represent the sync pref of the Mail application
  385.  
  386. @ISA = qw(PDA::Pilot::Pref);
  387.  
  388. sub Pack {
  389.     my($self) = @_;
  390.     return PDA::Pilot::Mail::PackSyncPref($self);
  391. }
  392.  
  393. sub Unpack {
  394.     my($self, $data) = @_;
  395.     $self->{raw} = $data;
  396.     PDA::Pilot::Mail::UnpackSyncPref($self);
  397. }
  398.  
  399. package PDA::Pilot::MailSignaturePref;
  400.  
  401. # A class to represent the signature pref of the Mail application
  402.  
  403. @ISA = qw(PDA::Pilot::Pref);
  404.  
  405. sub Pack {
  406.     my($self) = @_;
  407.     return PDA::Pilot::Mail::PackSignaturePref($self);
  408. }
  409.  
  410. sub Unpack {
  411.     my($self, $data) = @_;
  412.     $self->{raw} = $data;
  413.     PDA::Pilot::Mail::UnpackSignaturePref($self);
  414. }
  415.  
  416. package PDA::Pilot::ExpenseRecord;
  417.  
  418. # A class to represent records of the Expense application
  419.  
  420. @ISA = qw(PDA::Pilot::Record);
  421.  
  422. sub Pack {
  423.     my($self) = @_;
  424.     return PDA::Pilot::Expense::Pack($self);
  425. }
  426.  
  427. sub Unpack {
  428.     my($self, $data) = @_;
  429.     $self->{raw} = $data;
  430.     PDA::Pilot::Expense::Unpack($self);
  431. }
  432.  
  433. package PDA::Pilot::ExpenseAppBlock;
  434.  
  435. # A class to represent the app block of the Expense application
  436.  
  437. @ISA = qw(PDA::Pilot::AppBlock);
  438.  
  439. sub Pack {
  440.     my($self) = @_;
  441.     return PDA::Pilot::Expense::PackAppBlock($self);
  442. }
  443.  
  444. sub Unpack {
  445.     my($self, $data) = @_;
  446.     $self->{raw} = $data;
  447.     PDA::Pilot::Expense::UnpackAppBlock($self);
  448. }
  449.  
  450. package PDA::Pilot::ExpensePref;
  451.  
  452. # A class to represent the pref of the Expense application
  453.  
  454. @ISA = qw(PDA::Pilot::Pref);
  455.  
  456. sub Pack {
  457.     my($self) = @_;
  458.     return PDA::Pilot::Expense::PackPref($self);
  459. }
  460.  
  461. sub Unpack {
  462.     my($self, $data) = @_;
  463.     $self->{raw} = $data;
  464.     PDA::Pilot::Expense::UnpackPref($self);
  465. }
  466.  
  467. package PDA::Pilot::Database;
  468.  
  469. # A class to specify which classes are used for generic database entries
  470.  
  471. sub record { shift @_; PDA::Pilot::Record->new(@_) }
  472. sub resource { shift @_; PDA::Pilot::Resource->new(@_) }
  473. sub pref { shift @_; PDA::Pilot::Pref->new(@_) }
  474. sub appblock { shift @_; PDA::Pilot::AppBlock->new(@_) }
  475. sub sortblock { shift @_; PDA::Pilot::SortBlock->new(@_) }
  476.  
  477. package PDA::Pilot::MemoDatabase;
  478.  
  479. # A class to specify which classes are used for Memo database entries
  480.  
  481. @ISA=qw(PDA::Pilot::Database);
  482.  
  483. sub record { shift @_; PDA::Pilot::MemoRecord->new(@_) }
  484. sub appblock { shift @_; PDA::Pilot::MemoAppBlock->new(@_) }
  485. sub creator { 'memo' }
  486. sub dbname { 'MemoDB' }
  487.  
  488. package PDA::Pilot::ToDoDatabase;
  489.  
  490. @ISA=qw(PDA::Pilot::Database);
  491.  
  492. sub record { shift @_; PDA::Pilot::ToDoRecord->new(@_) }
  493. sub appblock { shift @_; PDA::Pilot::ToDoAppBlock->new(@_) }
  494. sub creator { 'todo' }
  495. sub dbname { 'ToDoDB' }
  496.  
  497. package PDA::Pilot::AppointmentDatabase;
  498.  
  499. @ISA=qw(PDA::Pilot::Database);
  500.  
  501. sub record { shift @_; PDA::Pilot::AppointmentRecord->new(@_) }
  502. sub appblock { shift @_; PDA::Pilot::AppointmentAppBlock->new(@_) }
  503. sub creator { 'date' }
  504. sub dbname { 'DatebookDB' }
  505.  
  506. package PDA::Pilot::AddressDatabase;
  507.  
  508. @ISA=qw(PDA::Pilot::Database);
  509.  
  510. sub record { shift @_; PDA::Pilot::AddressRecord->new(@_) }
  511. sub appblock { shift @_; PDA::Pilot::AddressAppBlock->new(@_) }
  512. sub creator { 'addr' }
  513. sub dbname { 'AddressDB' }
  514.  
  515. package PDA::Pilot::MailDatabase;
  516.  
  517. @ISA=qw(PDA::Pilot::Database);
  518.  
  519. sub record { shift @_; PDA::Pilot::MailRecord->new(@_) }
  520. sub appblock { shift @_; PDA::Pilot::MailAppBlock->new(@_) }
  521. sub pref {
  522.     shift @_;
  523.     my($data,$creator,$id) = @_;
  524.     if (($id == 1) || ($id == 2)) {
  525.         PDA::Pilot::MailSyncPref->new(@_);
  526.     } elsif ($id == 3) {
  527.         PDA::Pilot::MailSignaturePref->new(@_);
  528.     } else {
  529.         PDA::Pilot::Database->pref(@_);
  530.     }
  531. }
  532. sub creator { 'mail' }
  533. sub dbname { 'MailDB' }
  534.  
  535. package PDA::Pilot::ExpenseDatabase;
  536.  
  537. @ISA=qw(PDA::Pilot::Database);
  538.  
  539. sub record { shift @_; PDA::Pilot::ExpenseRecord->new(@_) }
  540. sub appblock { shift @_; PDA::Pilot::ExpenseAppBlock->new(@_) }
  541. sub pref {
  542.     shift @_;
  543.     my($data,$creator,$id) = @_;
  544.     if ($id == 1) {
  545.         PDA::Pilot::ExpensePref->new(@_);
  546.     } else {
  547.         PDA::Pilot::Database->pref(@_);
  548.     }
  549. }
  550. sub creator { 'exps' }
  551. sub dbname { 'ExpenseDB' }
  552.  
  553. package PDA::Pilot;
  554.  
  555. %DBClasses = (    MemoDB => 'PDA::Pilot::MemoDatabase',
  556.                 ToDoDB => 'PDA::Pilot::ToDoDatabase',
  557.                 AddressDB => 'PDA::Pilot::AddressDatabase',
  558.                 DatebookDB => 'PDA::Pilot::AppointmentDatabase',
  559.                 MailDB => 'PDA::Pilot::MailDatabase',
  560.                 ExpenseDB => 'PDA::Pilot::ExpenseDatabase'
  561.                 );
  562. %PrefClasses = (    memo => 'PDA::Pilot::MemoDatabase',
  563.                     todo => 'PDA::Pilot::ToDoDatabase',
  564.                     mail => 'PDA::Pilot::MailDatabase',
  565.                     date => 'PDA::Pilot::AppointmentDatabase',
  566.                     addr => 'PDA::Pilot::AddressDatabase',
  567.                     exps => 'PDA::Pilot::ExpenseDatabase'
  568.                     );
  569.  
  570. # Default classes
  571. $DBClasses{''} = 'PDA::Pilot::Database';
  572. $PrefClasses{''} = 'PDA::Pilot::Database';
  573.  
  574. sub CompareTm {
  575.     my(@a) = @{$_[0]};
  576.     my(@b) = @{$_[1]};
  577.     return ($a[5] <=> $b[5]) || ($a[4] <=> $b[4]) || ($a[3] <=> $b[3]) ||
  578.            ($a[2] <=> $b[2]) || ($a[1] <=> $b[1]) || ($a[0] <=> $b[0]);
  579. }
  580.  
  581. # Autoload methods go after __END__, and are processed by the autosplit program.
  582.  
  583. 1;
  584. __END__
  585.  
  586. =head1
  587.  
  588. Commands include:
  589.  
  590. B<Notice!> This information is out of date, and potentially quite
  591. misleading.
  592.  
  593. =over 4
  594.  
  595. =item PDA::Pilot::Appointment::Unpack(buffer) 
  596.  
  597. Returns hash reference containing appointment (datebook entry) in a usable
  598. format, given a record from a .pdb file or a Pilot database.
  599.  
  600. =item PDA::Pilot::Appointment::Pack(buffer) 
  601.  
  602. Given a hash reference in the form that the previous call generates, returns 
  603. a single string suitable for storing in a Pilot's database.
  604.  
  605. =item PDA::Pilot::Appointment::UnpackAppInfo(buffer) 
  606.  
  607. Returns hash reference containing appointment (datebook entry) in a usable
  608. format, given the AppInfo record from a .pdb file or a Pilot database.
  609.  
  610. =item PDA::Pilot::Appointment::PackAppInfo(buffer) 
  611.  
  612. Given a hash reference in the form that the previous call generates, returns 
  613. a single string suitable for storing in a Pilot's database AppInfo block.
  614.  
  615. =item PDA::Pilot::Memo::Unpack(buffer) 
  616.  
  617. Returns hash reference containing appointment (datebook entry) in a usable
  618. format, given a record from a .pdb file or a Pilot database.
  619.  
  620. =item PDA::Pilot::Memo::Pack(buffer) 
  621.  
  622. Given a hash reference in the form that the previous call generates, returns 
  623. a single string suitable for storing in a Pilot's database.
  624.  
  625. =item PDA::Pilot::Memo::UnpackAppInfo(buffer) 
  626.  
  627. Returns hash reference containing appointment (datebook entry) in a usable
  628. format, given the AppInfo record from a .pdb file or a Pilot database.
  629.  
  630. =item PDA::Pilot::Memo::PackAppInfo(buffer) 
  631.  
  632. Given a hash reference in the form that the previous call generates, returns 
  633. a single string suitable for storing in a Pilot's database AppInfo block.
  634.  
  635. =item PDA::Pilot::ToDo::Unpack(buffer) 
  636.  
  637. Returns hash reference containing appointment (datebook entry) in a usable
  638. format, given a record from a .pdb file or a Pilot database.
  639.  
  640. =item PDA::Pilot::ToDo::Pack(buffer) 
  641.  
  642. Given a hash reference in the form that the previous call generates, returns 
  643. a single string suitable for storing in a Pilot's database.
  644.  
  645. =item PDA::Pilot::ToDo::UnpackAppInfo(buffer) 
  646.  
  647. Returns hash reference containing appointment (datebook entry) in a usable
  648. format, given the AppInfo record from a .pdb file or a Pilot database.
  649.  
  650. =item PDA::Pilot::ToDo::PackAppInfo(buffer) 
  651.  
  652. Given a hash reference in the form that the previous call generates, returns 
  653. a single string suitable for storing in a Pilot's database AppInfo block.
  654.  
  655. =item PDA::Pilot::Address::Unpack(buffer) 
  656.  
  657. Returns hash reference containing appointment (datebook entry) in a usable
  658. format, given a record from a .pdb file or a Pilot database.
  659.  
  660. =item PDA::Pilot::Address::Pack(buffer) 
  661.  
  662. Given a hash reference in the form that the previous call generates, returns 
  663. a single string suitable for storing in a Pilot's database.
  664.  
  665. =item PDA::Pilot::Address::UnpackAppInfo(buffer) 
  666.  
  667. Returns hash reference containing appointment (datebook entry) in a usable
  668. format, given the AppInfo record from a .pdb file or a Pilot database.
  669.  
  670. =item PDA::Pilot::Address::PackAppInfo(buffer) 
  671.  
  672. Given a hash reference in the form that the previous call generates, returns 
  673. a single string suitable for storing in a Pilot's database AppInfo block.
  674.  
  675. =item PDA::Pilot::Mail::Unpack(buffer) 
  676.  
  677. Returns hash reference containing appointment (datebook entry) in a usable
  678. format, given a record from a .pdb file or a Pilot database.
  679.  
  680. =item PDA::Pilot::Mail::Pack(buffer) 
  681.  
  682. Given a hash reference in the form that the previous call generates, returns 
  683. a single string suitable for storing in a Pilot's database.
  684.  
  685. =item PDA::Pilot::Mail::UnpackAppInfo(buffer) 
  686.  
  687. Returns hash reference containing appointment (datebook entry) in a usable
  688. format, given the AppInfo record from a .pdb file or a Pilot database.
  689.  
  690. =item PDA::Pilot::Mail::PackAppInfo(buffer) 
  691.  
  692. Given a hash reference in the form that the previous call generates, returns 
  693. a single string suitable for storing in a Pilot's database AppInfo block.
  694.  
  695. =item PDA::Pilot::Socket::socket(domain, type, protocol)
  696.  
  697. Same as pi-link routine called pi_socket.
  698.  
  699. =item PDA::Pilot::Socket::close(socket)
  700.  
  701. Same as pi-link routine called pi_close.
  702.  
  703. =item PDA::Pilot::Socket::write(socket, string)
  704.  
  705. Same as pi-link routine called pi_write.
  706.  
  707. =item PDA::Pilot::Socket::read(socket, len)
  708.  
  709. Same as pi-link routine called pi_write (returns read data as result.)
  710.  
  711. =item PDA::Pilot::Socket::listen(socket, backlog)
  712.  
  713. Same as pi-link routine called pi_listen.
  714.  
  715. =item PDA::Pilot::Socket::bind(socket, sockaddr)
  716.  
  717. Same as pi-link routine called pi_bind. Sockaddr may either be a packed
  718. string containing a pi_sockaddr structure, or a hash reference containing
  719. "device", "family", and "port" keys.
  720.  
  721. =item PDA::Pilot::Socket::accept(socket)
  722.  
  723. Same as pi-link routine called pi_accept. If connection is successfull, returns
  724. reference to hash containing remote address, as described above. If failed, returns
  725. undef.
  726.  
  727. =item PDA::Pilot::DLP::errno()
  728.  
  729. Returns last DLP error, resetting error to zero.
  730.  
  731. =item PDA::Pilot::DLP::GetSysDateTime(socket)
  732.  
  733. Same as DLP call dlp_GetSysDateTime. If successfull, returns time, otherwise
  734. returns undef.
  735.  
  736. =item PDA::Pilot::DLP::SetSysDateTime(socket, time)
  737.  
  738. Same as DLP call dlp_SetSysDateTime. time must be a time_t value.
  739.  
  740. =item PDA::Pilot::DLP::ReadSysInfo(socket)
  741.  
  742. Same as DLP call dlp_ReadSysInfo. If successfull, returns reference to hash
  743. containing system information.
  744.  
  745. =item PDA::Pilot::DLP::ReadStorageInfo(socket, cardno)
  746.  
  747. Same as DLP call dlp_ReadStorageInfo. If successfull, returns reference to hash
  748. containing information on given memory card.
  749.  
  750. =item PDA::Pilot::DLP::ReadUserInfo(socket)
  751.  
  752. Same as DLP call dlp_ReadUserInfo. If successfull, returns reference to hash
  753. containing information about user settings.
  754.  
  755. =item PDA::Pilot::DLP::WriteUserInfo(socket, info)
  756.  
  757. Same as DLP call dlp_WriteUserInfo. info must be a reference to a hash
  758. containing data similar to that returned by ReadUserInfo (Note: the password
  759. can not be set through this call.)
  760.  
  761. =item PDA::Pilot::DLP::OpenDB(socket, cardno, mode, name)
  762.  
  763. Same as DLP call dlp_OpenDB. If successfull returns database handle,
  764. otherwise returns undef.
  765.  
  766. =item PDA::Pilot::DLP::CloseDB(socket, handle)
  767.  
  768. Same as DLP call dlp_CloseDB. 
  769.  
  770. =item PDA::Pilot::DLP::EndOfSync(socket, status)
  771.  
  772. Same as DLP call dlp_EndOfSync. 
  773.  
  774. =item PDA::Pilot::DLP::AbortSync(socket)
  775.  
  776. Same as DLP call dlp_AbortSync. 
  777.  
  778. =item PDA::Pilot::DLP::MoveCategory(socket, handle, fromcat, tocat)
  779.  
  780. Same as DLP call dlp_MoveCategory. 
  781.  
  782. =item PDA::Pilot::DLP::ResetSystem(socket)
  783.  
  784. Same as DLP call dlp_ResetSystem. 
  785.  
  786. =item PDA::Pilot::DLP::OpenConduit(socket)
  787.  
  788. Same as DLP call dlp_OpenConduit. 
  789.  
  790. =item PDA::Pilot::DLP::AddSyncLogEntry(socket, message)
  791.  
  792. Same as DLP call dlp_AddSyncLogEntry 
  793.  
  794. =item PDA::Pilot::DLP::CleanUpDatabase(socket, handle)
  795.  
  796. Same as DLP call dlp_CleanUpDatabase. 
  797.  
  798. =item PDA::Pilot::DLP::ResetSyncFlags(socket, handle)
  799.  
  800. Same as DLP call dlp_ResetSyncFlags. 
  801.  
  802. =item PDA::Pilot::DLP::ResetDBIndex(socket, handle)
  803.  
  804. Same as DLP call dlp_ResetDBIndex. 
  805.  
  806. =item PDA::Pilot::DLP::ResetLastSyncPC(socket)
  807.  
  808. Same as DLP call dlp_ResetLastSyncPC. 
  809.  
  810. =item PDA::Pilot::DLP::DeleteCategory(socket, handle, category)
  811.  
  812. Same as DLP call dlp_DeleteCategory. 
  813.  
  814. =item PDA::Pilot::DLP::DeleteRecord(socket, handle, all, id)
  815.  
  816. Same as DLP call dlp_DeleteRecord. 
  817.  
  818. =item PDA::Pilot::DLP::ReadDBList(socket, cardno, flags, start)
  819.  
  820. Same as DLP call dlp_ReadDBList. If successfull, returns reference
  821. to hash containing DB information. If failed, returns undef.
  822.  
  823. =item PDA::Pilot::DLP::FindDBInfo(socket, cardno, flags, name, type, creator)
  824.  
  825. Same as DLP call dlp_FindDBInfo. If successfull, returns reference
  826. to hash containing DB information. If failed, returns undef.
  827.  
  828. =item PDA::Pilot::DLP::ReadFeature(socket, creator, number)
  829.  
  830. Same as DLP call dlp_ReadFeature. If successfull, returns feature value. If
  831. failed, returns undef.
  832.  
  833. =item PDA::Pilot::DLP::ReadAppBlock(socket, handle)
  834.  
  835. Same as DLP call dlp_ReadAppBlock. If successfull, returns app block. If
  836. failed, returns undef.
  837.  
  838. =item PDA::Pilot::DLP::ReadSortBlock(socket, handle)
  839.  
  840. Same as DLP call dlp_ReadSortBlock. If successfull, returns app block. If
  841. failed, returns undef.
  842.  
  843. =item PDA::Pilot::DLP::WriteAppBlock(socket, handle, block)
  844.  
  845. Same as DLP call dlp_WriteAppBlock.
  846.  
  847. =item PDA::Pilot::DLP::WriteSortBlock(socket, handle, block)
  848.  
  849. Same as DLP call dlp_WriteSortBlock.
  850.  
  851. =item PDA::Pilot::DLP::ReadOpenDBInfo(socket, handle)
  852.  
  853. Same as DLP call dlp_ReadOpenDBInfo.
  854.  
  855. =item PDA::Pilot::DLP::ReadRecordByIndex(socket, handle, index)
  856.  
  857. Same as DLP call dlp_ReadRecordByIndex. If call fails, it returns undef.
  858. Otherwise, in scalar context it returns the read record, in array it returns
  859. the record, id, index, attr, and category, in that order.
  860.  
  861. =item PDA::Pilot::DLP::ReadRecordById(socket, handle, id)
  862.  
  863. Same as DLP call dlp_ReadRecordById. If call fails, it returns undef.
  864. Otherwise, in scalar context it returns the read record, in array it returns
  865. the record, id, index, attr, and category, in that order.
  866.  
  867. =item PDA::Pilot::DLP::ReadNextModifiedRec(socket, handle)
  868.  
  869. Same as DLP call dlp_ReadNextModifiedRec. If call fails, it returns undef.
  870. Otherwise, in scalar context it returns the read record, in array it returns
  871. the record, id, index, attr, and category, in that order.
  872.  
  873. =item PDA::Pilot::DLP::ReadNextRecInCategory(socket, handle, category)
  874.  
  875. Same as DLP call dlp_ReadNextRecInCategory. If call fails, it returns undef.
  876. Otherwise, in scalar context it returns the read record, in array it returns
  877. the record, id, index, attr, and category, in that order.
  878.  
  879. =item PDA::Pilot::DLP::ReadNextModifiedRecInCategory(socket, handle, category)
  880.  
  881. Same as DLP call dlp_ReadNextModifiedRecInCategory. If call fails, it returns undef.
  882. Otherwise, in scalar context it returns the read record, in array it returns
  883. the record, id, index, attr, and category, in that order.
  884.  
  885. =item PDA::Pilot::DLP::WriteRecord(socket, handle, record, id, attr, category)
  886.  
  887. Same as DLP call dlp_WriteRecord.
  888.  
  889. =item PDA::Pilot::DLP::ReadResourceByType(socket, handle, type, id)
  890.  
  891. Same as DLP call dlp_ReadResourceByType. If call fails, it returns undef.
  892. Otherwise, in scalar context it returns the read record, in array it returns
  893. the record, type, id, and index, in that order.
  894.  
  895. =item PDA::Pilot::DLP::ReadResourceByIndex(socket, handle, index)
  896.  
  897. Same as DLP call dlp_ReadResourceByIndex. If call fails, it returns undef.
  898. Otherwise, in scalar context it returns the read record, in array it returns
  899. the record, type, id, and index, in that order.
  900.  
  901. =item PDA::Pilot::DLP::WriteResource(socket, handle, record, type, id)
  902.  
  903. Same as DLP call dlp_WriteResource.
  904.  
  905. =item PDA::Pilot::DLP::DeleteResource(socket, handle, all, type, id)
  906.  
  907. Same as DLP call dlp_DeleteResource.
  908.  
  909. =item PDA::Pilot::DLP::CallApplication(socket, creator, type, action, data)
  910.  
  911. Same as DLP call dlp_CallApplication.
  912.  
  913. =item PDA::Pilot::File::open(name)
  914.  
  915. Same as pi_file_open. Returns a PDA::Pilot::File object on success.
  916.  
  917. =item PDA::Pilot::File::close(file)
  918.  
  919. Same as pi_file_close.
  920.  
  921. =item PDA::Pilot::File::get_app_info(file)
  922.  
  923. Same as pi_file_get_app_info.
  924.  
  925. =item PDA::Pilot::File::get_sort_info(file)
  926.  
  927. Same as pi_file_get_sort_info.
  928.  
  929. =item PDA::Pilot::File::get_entries(file)
  930.  
  931. Same as pi_file_get_entries.
  932.  
  933. =item PDA::Pilot::File::read_resource(file, index)
  934.  
  935. Same as pi_file_read_resource. Returns (record, type, id, index).
  936.  
  937. =item PDA::Pilot::File::read_record(file, index)
  938.  
  939. Same as pi_file_read_record. Returns (record, id, index, attr, category).
  940.  
  941. =item PDA::Pilot::File::read_record_by_id(file, type, id)
  942.  
  943. Same as pi_file_read_record_by_id. Returns (record, id, index, attr, category).
  944.  
  945. =item PDA::Pilot::File::create(name, info)
  946.  
  947. Same as pi_file_create. Info is reference to hash containg dbinfo data.
  948.  
  949. =item PDA::Pilot::File::get_info(file)
  950.  
  951. Same as pi_file_get_info.
  952.  
  953. =item PDA::Pilot::File::set_info(file, info)
  954.  
  955. Same as pi_file_set_info.
  956.  
  957. =item PDA::Pilot::File::set_app_info(file, data)
  958.  
  959. Same as pi_file_set_app_info.
  960.  
  961. =item PDA::Pilot::File::set_sort_info(file, data)
  962.  
  963. Same as pi_file_set_sort_info.
  964.  
  965. =item PDA::Pilot::File::append_resource(file, data, type, id)
  966.  
  967. Same as pi_file_append_resource.
  968.  
  969. =item PDA::Pilot::File::append_record(file, data, attr, category, id)
  970.  
  971. Same as pi_file_append_record.
  972.  
  973. =item PDA::Pilot::File::install(file, socket, cardno)
  974.  
  975. Same as pi_file_install.
  976.  
  977. =item PDA::Pilot::File::retrieve(file, socket, cardno)
  978.  
  979. Same as pi_file_retrieve.
  980.  
  981. =back
  982.  
  983. =cut
  984.